home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / ExecLists.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  13KB  |  619 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysExecLists.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    void MakeIntrList ( void );
  12.    *    void MakeLibList ( void );
  13.    *    void MakePortList ( void );
  14.    *    void MakeResList ( void );
  15.    *    void MakeTaskList ( void );
  16.    *    void RSysMemoryAreaList ( void );
  17.    *    void SysSemaphoreList ( void );
  18.    *    void SysSoftDeviceList ( void );
  19.    *    void SysVectorList ( void );
  20.    *
  21.    *      --- Lokale  Routinen ---
  22.    *
  23.    *    static void CopyTaskNode ( int entrynum , NODE *node );
  24.    *
  25.    * Bemerkungen:
  26.    *      Erzeugung von EXEC-Listen (Tasks, Ports, Libraries etc.).
  27.    *
  28.    * Erstellungsdatum:
  29.    *      07-Jul-93     Rolf Böhme
  30.    *
  31.    * Änderungen:
  32.    *      07-Jul-93     Rolf Böhme        Erstellung
  33.    *
  34.    ***************************************************************************
  35.  */
  36.  
  37. #include "RSys.h"
  38. #include "protos.h"
  39.  
  40.  /*
  41.   * MakeLibList() erzeugt eine Liste aus allen im System
  42.   * angemeldeten Libraries.
  43.   */
  44. void
  45. MakeLibList (void)
  46. {
  47.   NODE *node;
  48.   LIBRARY *lib;
  49.   int i = 0;
  50.  
  51.   DPOS;
  52.  
  53.   countentries = CountNodes (&SysBase->LibList);
  54.  
  55.   if (NoEntries ())
  56.     return;
  57.  
  58.   Entries = AllocScrollEntries (countentries);
  59.  
  60.   Forbid ();
  61.  
  62.   for (node = SysBase->LibList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  63.     {
  64.       lib = (LIBRARY *) node;
  65.  
  66.       Entries[i].se_obj_id.address = lib;
  67.       savestrcpy (Entries[i].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_LIBRARY);
  68.  
  69.       sprintf (Entries[i].se_Entry, EntryAttr[LIBRARIES].ea_dataformat,
  70.            Entries[i].se_obj_id.address,
  71.            Entries[i].se_obj_id.fullname,
  72.            lib->lib_Version,
  73.            lib->lib_Revision,
  74.            lib->lib_OpenCnt,
  75.            (lib->lib_OpenCnt ? '*' : ' '));
  76.  
  77.       i++;
  78.     }
  79.  
  80.   countentries = i;
  81.  
  82.   Permit ();
  83.  
  84.   CreateEntryList (SORT, 9);
  85.  
  86.   return;
  87. }
  88.  
  89.  /*
  90.   * MakeResList() erzeugt eine Liste der Ressourcen, die
  91.   * in der ExecBase eingetragen sind
  92.   */
  93. void
  94. MakeResourceList (void)
  95. {
  96.   NODE *node;
  97.   LIBRARY *lib;
  98.   int i;
  99.  
  100.   DPOS;
  101.  
  102.   countentries = CountNodes (&SysBase->ResourceList);
  103.  
  104.   if (NoEntries ())
  105.     return;
  106.  
  107.   Entries = AllocScrollEntries (countentries);
  108.  
  109.   Forbid ();
  110.  
  111.   i = 0;
  112.  
  113.   for (node = SysBase->ResourceList.lh_Head;
  114.        node->ln_Succ && (i < countentries); node = node->ln_Succ)
  115.     {
  116.       lib = (LIBRARY *) node;
  117.  
  118.       Entries[i].se_obj_id.address = lib;
  119.       savestrcpy (Entries[i].se_obj_id.fullname, node,
  120.           MAXFULLNAME - 1, NT_RESOURCE);
  121.  
  122.       sprintf (Entries[i].se_Entry, EntryAttr[RESOURCES].ea_dataformat,
  123.            Entries[i].se_obj_id.address,
  124.            Entries[i].se_obj_id.fullname,
  125.            lib->lib_Version,
  126.            lib->lib_Revision,
  127.            lib->lib_OpenCnt);
  128.  
  129.       i++;
  130.     }
  131.  
  132.   countentries = i;
  133.  
  134.   Permit ();
  135.  
  136.   CreateEntryList (SORT, 9);
  137.  
  138.   return;
  139. }
  140.  
  141.  /*
  142.   * MakeIntrList() listet alle 16 Interrupts auf, die vom System
  143.   * verwaltet werden können
  144.   */
  145. void
  146. MakeIntrList (void)
  147. {
  148.   NODE *node;
  149.   int i;
  150.  
  151.   DPOS;
  152.  
  153.   countentries = 16;        /* IntVects size */
  154.  
  155.   Entries = AllocScrollEntries (countentries);
  156.  
  157.   Disable ();
  158.  
  159.   for (i = 0; i < countentries; i++)
  160.     {
  161.       node = SysBase->IntVects[i].iv_Node;
  162.  
  163.       Entries[i].se_obj_id.address = node;
  164.       if (node && (node->ln_Name))    /*GMD */
  165.     {
  166.  
  167.       savestrcpy (Entries[i].se_obj_id.fullname, node,
  168.               MAXFULLNAME - 1, node->ln_Type);    /*hack */
  169.  
  170.       sprintf (Entries[i].se_Entry, EntryAttr[INTERRUPTS].ea_dataformat,
  171.            Entries[i].se_obj_id.address,
  172.            Entries[i].se_obj_id.fullname,
  173.            node->ln_Pri,
  174.            (long) ((INTERRUPT *) node)->is_Data,
  175.            (long) (((INTERRUPT *) node)->is_Code));
  176.     }
  177.       else
  178.     {
  179.       sprintf (Entries[i].se_Entry, EntryAttr[INTERRUPTS].ea_dataformat,
  180.            0L, field[NO_NODE], 0, 0L, 0L);
  181.     }
  182.     }
  183.  
  184.   Enable ();
  185.  
  186.   CreateEntryList (NO_SORT, 9);
  187.  
  188.   return;
  189. }
  190.  
  191.  /*
  192.   * MakePortList() erzeugt eine Liste der im System angemeldeten
  193.   * öffentlichen Ports
  194.   */
  195. void
  196. MakePortList (void)
  197. {
  198.   NODE *node;
  199.   TASK *task;
  200.   MSGPORT *port;
  201.   char sigtask[16];
  202.   int i = 0;
  203.  
  204.   DPOS;
  205.  
  206.   countentries = CountNodes (&SysBase->PortList);
  207.  
  208.   if (NoEntries ())
  209.     return;
  210.  
  211.   Entries = AllocScrollEntries (countentries);
  212.  
  213.   Forbid ();
  214.  
  215.   for (node = SysBase->PortList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  216.     {
  217.       Entries[i].se_obj_id.address = node;
  218.       savestrcpy (Entries[i].se_obj_id.fullname, node,
  219.           MAXFULLNAME - 1, NT_MSGPORT);
  220.  
  221.       port = (MSGPORT *) node;
  222.       task = (TASK *) port->mp_SigTask;
  223.       if (task)
  224.     savestrcpy (sigtask, &(task->tc_Node), 15, NT_TASK);
  225.       else
  226.     strcpy (sigtask, field[NO_TASK]);
  227.  
  228.       sprintf (Entries[i].se_Entry, EntryAttr[PORTS].ea_dataformat,
  229.            Entries[i].se_obj_id.address,
  230.            Entries[i].se_obj_id.fullname,
  231.            sigtask, node->ln_Pri);
  232.  
  233.       i++;
  234.     }
  235.  
  236.   countentries = i;
  237.  
  238.   Permit ();
  239.  
  240.   CreateEntryList (SORT, 9);
  241.  
  242.   return;
  243. }
  244.  
  245.  
  246.  /*
  247.   * CopyTaskNode() kopiert die Daten eines Tasks in eine interne
  248.   * Listenstruktur
  249.   */
  250. static void
  251. CopyTaskNode (int entrynum, NODE * node)
  252. {
  253.   COMMANDLINEINTERFACE *CLI;
  254.   PROCESS *proc;
  255.   char *status[] =
  256.   {
  257.     "Inv", "Add", "Run", "Rdy", "Wait", "Excp", "Rem"
  258.   }, cli[5], buf[BUFSIZE], backtask[BUFSIZE], *backtaskstr = NULL;
  259.  
  260.   Entries[entrynum].se_obj_id.address = node;
  261.  
  262.   savestrcpy (Entries[entrynum].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_TASK);
  263.  
  264.   if (!strcmp (Entries[entrynum].se_obj_id.fullname, "Background CLI") ||
  265.       !strcmp (Entries[entrynum].se_obj_id.fullname, "Shell Process"))
  266.     {
  267.       proc = (PROCESS *) node;
  268.       CLI = (COMMANDLINEINTERFACE *) BADDR (proc->pr_CLI);
  269.  
  270.       backtaskstr = B2CStr (buf, CLI->cli_CommandName);
  271.       buf[15] = STRINGEND;
  272.  
  273.       if (strlen (backtaskstr) != 0)
  274.     sprintf (backtask, "[%s]", buf);
  275.       else
  276.     strcpy (backtask, "[no command]");
  277.     }
  278.  
  279.   if ((node->ln_Type == NT_PROCESS) && ((PROCESS *) node)->pr_CLI)
  280.     sprintf (cli, "%3ld", ((PROCESS *) node)->pr_TaskNum);
  281.   else
  282.     strcpy (cli, field[NO_FIELD]);
  283.  
  284.   sprintf (Entries[entrynum].se_Entry, EntryAttr[TASKS].ea_dataformat,
  285.        Entries[entrynum].se_obj_id.address,
  286.        backtaskstr ? backtask : Entries[entrynum].se_obj_id.fullname,
  287.        (node->ln_Type == NT_PROCESS) ? (char *) "Proc" : (char *) "Task",
  288.        node->ln_Pri,
  289.        ((ULONG) ((TASK *) node)->tc_SPUpper -
  290.         (ULONG) ((TASK *) node)->tc_SPLower),
  291.        status[((TASK *) node)->tc_State],
  292.        cli);
  293.   return;
  294. }
  295.  
  296.  /*
  297.   * MakeTaskList() erzeugt eine Liste der im System angemeldeten Tasks und
  298.   * Prozesse
  299.   */
  300. void
  301. MakeTaskList (void)
  302. {
  303.   NODE *node, **membernode;
  304.   int i = 0;
  305.   int tasks, processes;        /*GMD */
  306.  
  307.   DPOS;
  308.  
  309.   tasks = CountNodesType (&SysBase->TaskWait, NT_TASK);
  310.   tasks += CountNodesType (&SysBase->TaskReady, NT_TASK);
  311.   countentries = tasks;
  312.  
  313.   processes = CountNodesType (&SysBase->TaskWait, NT_PROCESS);
  314.   processes += CountNodesType (&SysBase->TaskReady, NT_PROCESS) + 1;
  315.  
  316.   countentries += processes;
  317.  
  318.  
  319.   if (NoEntries ())
  320.     return;
  321.  
  322.   Entries = AllocScrollEntries (countentries);
  323.  
  324.   membernode = (NODE **) MyAllocVec (countentries * sizeof (NODE *),
  325.                      MEMF_ANY | MEMF_CLEAR, KILL);
  326.  
  327. #if 0
  328. /* *INDENT-OFF* */
  329.  
  330. * /* GMD; this Forbid/Disable looks suspect!! */
  331. *   Forbid ();
  332. *   Disable ();
  333. * 
  334. *   for (node = SysBase->TaskWait.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  335. *     membernode[i++] = node;
  336. * 
  337. *   for (node = SysBase->TaskReady.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  338. *     membernode[i++] = node;
  339. * 
  340. *   if (i < countentries)
  341. *     membernode[i++] = &SysBase->ThisTask->tc_Node;
  342. * 
  343. *   Enable ();
  344. * 
  345. *   countentries = i;
  346. * 
  347. *   for (i = 0; i < countentries; i++)
  348. *     CopyTaskNode (i, membernode[i]);
  349. * 
  350. *   Permit ();
  351. *   Forbid ();
  352. /* *INDENT-ON* */
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359.  
  360.  
  361.  
  362.  
  363.  
  364. #endif
  365.  
  366.  
  367.   Forbid ();
  368.  
  369.   i = 0;
  370.  
  371.   for (node = SysBase->TaskWait.lh_Head;
  372.        node->ln_Succ && (i < countentries); node = node->ln_Succ)
  373.     {
  374.       membernode[i++] = node;
  375.     }
  376.  
  377.   for (node = SysBase->TaskReady.lh_Head;
  378.        node->ln_Succ && (i < countentries); node = node->ln_Succ)
  379.     {
  380.       membernode[i++] = node;
  381.     }
  382.  
  383.   if (i < countentries)
  384.     {
  385.       membernode[i++] = &SysBase->ThisTask->tc_Node;
  386.     }
  387.  
  388.   countentries = i;
  389.  
  390.   for (i = 0; i < countentries; i++)
  391.     {
  392.       CopyTaskNode (i, membernode[i]);
  393.     }
  394.  
  395.   Permit ();
  396.  
  397.   /*
  398.    * now build a message for PrintStatistics() GMD
  399.    */
  400.   sprintf (gbuf, "Tasks = %d , Processes = %d", tasks, processes);
  401.  
  402.   MyFreeVec (membernode);
  403.  
  404.   CreateEntryList (SORT, 9);
  405.  
  406.   return;
  407. }
  408.  
  409.  /*
  410.   * SysSemaphoreList() listet alle angemeldeten Semaphoren
  411.   * auf, die in der ExecBase eingetragen sind
  412.   */
  413. void
  414. SysSemaphoreList (void)
  415. {
  416.   NODE *node;
  417.   int i = 0;
  418.   SIGNALSEMAPHORE *SigSem;
  419.   char name[23], sigtask[20];
  420.  
  421.   DPOS;
  422.  
  423.   HandleHelp (MN_SysSemaphoreList);
  424.  
  425.   PrintHeader (SEMAPHORES, NULL);
  426.  
  427.   EmptyListView ();
  428.  
  429.   countentries = CountNodes (&SysBase->SemaphoreList);
  430.  
  431.   if (NoEntries ())
  432.     return;
  433.  
  434.   Entries = AllocScrollEntries (countentries);
  435.  
  436.   Forbid ();
  437.  
  438.   for (node = SysBase->SemaphoreList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  439.     {
  440.       SigSem = (SIGNALSEMAPHORE *) node;
  441.  
  442.       savestrcpy (name, node, 22, NT_SEMAPHORE);
  443.  
  444.       if (SigSem->ss_Owner)
  445.     savestrcpy (sigtask, &(SigSem->ss_Owner->tc_Node), 19, NT_TASK);
  446.       else
  447.     strcpy (sigtask, field[NO_TASK]);
  448.  
  449.       Entries[i].se_obj_id.address = node;
  450.  
  451.       sprintf (Entries[i].se_Entry, EntryAttr[SEMAPHORES].ea_dataformat,
  452.            Entries[i].se_obj_id.address,
  453.            name, node->ln_Pri, sigtask);
  454.  
  455.       i++;
  456.     }
  457.  
  458.   countentries = i;
  459.  
  460.   Permit ();
  461.  
  462.   CreateEntryList (SORT, 9);
  463.  
  464.   PrintStatistics ();
  465.  
  466.   return;
  467. }
  468.  
  469.  /*
  470.   * SysVectorList() erzeugt eine Liste aller "kritischen"
  471.   * Systemvektoren. Ist eine von ihnen ungleich NULL,
  472.   * sollte dem nachgegangen werden, da diese eine beliebte
  473.   * Einsprungadresse für Viren darstellen
  474.   */
  475. void
  476. SysVectorList (void)
  477. {
  478.   EXECBASE CopySysBase;
  479.   int i = 0;
  480.  
  481.   HandleHelp (MN_SysVectorList);
  482.  
  483.   DPOS;
  484.  
  485.   PrintHeader (SYSVECTORS, NULL);
  486.  
  487.   EmptyListView ();
  488.  
  489.   countentries = 14;
  490.  
  491.   Entries = AllocScrollEntries (countentries);
  492.  
  493.   Forbid ();
  494.   CopyMem ((APTR) SysBase, (APTR) & CopySysBase, sizeof (EXECBASE));
  495.   Permit ();
  496.  
  497.   strcpy (Entries[i].se_Entry, "----- Capture vectors");
  498.   AddNodeToList (i++, NO_SORT, 0);
  499.  
  500.   MakeHexEntry (&i, "ColdCapture", CopySysBase.ColdCapture);
  501.   MakeHexEntry (&i, "CoolCapture", CopySysBase.CoolCapture);
  502.   MakeHexEntry (&i, "WarmCapture", CopySysBase.WarmCapture);
  503.  
  504.  
  505.   MakeHeadEntry (&i, "----- Kick pointer");
  506.  
  507.   MakeHexEntry (&i, "KickMemPtr", CopySysBase.KickMemPtr);
  508.   MakeHexEntry (&i, "KickTagPtr", CopySysBase.KickTagPtr);
  509.   MakeHexEntry (&i, "KickCheckSum", CopySysBase.KickCheckSum);
  510.  
  511.   MakeHeadEntry (&i, "----- Exec special pointer");
  512.  
  513.   MakeHexEntry (&i, "Debug entry", CopySysBase.DebugEntry);
  514.   MakeHexEntry (&i, "ResModules", CopySysBase.ResModules);
  515.   MakeHexEntry (&i, "MMU-Lock", CopySysBase.ex_MMULock);
  516.  
  517.   PrintStatistics ();
  518.  
  519.   return;
  520. }
  521.  
  522.  /*
  523.   * SysSoftDeviceList() listet alle *.device auf, die in
  524.   * der ExecBase angemeldet sind
  525.   */
  526. void
  527. SysSoftDeviceList (void)
  528. {
  529.   NODE *node;
  530.   LIBRARY *device_lib;
  531.   int i = 0;
  532.  
  533.   HandleHelp (MN_SysSoftDeviceList);
  534.  
  535.   DPOS;
  536.  
  537.   PrintHeader (SYSSOFTDEV, NULL);
  538.  
  539.   EmptyListView ();
  540.  
  541.   countentries = CountNodes (&SysBase->DeviceList);
  542.  
  543.   if (NoEntries ())
  544.     return;
  545.  
  546.   Entries = AllocScrollEntries (countentries);
  547.  
  548.   Forbid ();
  549.  
  550.   for (node = SysBase->DeviceList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  551.     {
  552.       device_lib = &((DEVICE *) node)->dd_Library;
  553.  
  554.       Entries[i].se_obj_id.address = device_lib;
  555.       savestrcpy (Entries[i].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_DEVICE);
  556.  
  557.       sprintf (Entries[i].se_Entry, EntryAttr[RESOURCES].ea_dataformat,
  558.            Entries[i].se_obj_id.address,
  559.            Entries[i].se_obj_id.fullname,
  560.            device_lib->lib_Version,
  561.            device_lib->lib_Revision,
  562.            device_lib->lib_OpenCnt);
  563.       i++;
  564.     }
  565.  
  566.   countentries = i;
  567.  
  568.   Permit ();
  569.  
  570.   CreateEntryList (SORT, 9);
  571.  
  572.   PrintStatistics ();
  573.  
  574.   return;
  575. }
  576.  
  577. void
  578. RSysMemoryAreaList (void)
  579. {
  580.   NODE *node;
  581.   RSYS_ValidMemoryNode *vmnode;
  582.   int i = 0;
  583.  
  584.   DPOS;
  585.  
  586.   PrintHeader (MEMORYAREAS, NULL);
  587.  
  588.   EmptyListView ();
  589.  
  590.   if (!Flags.dummy4)
  591.     return;
  592.  
  593.   countentries = CountNodes (&ValidMemoryList);
  594.  
  595.   Entries = AllocScrollEntries (countentries);
  596.  
  597.   for (node = ValidMemoryList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  598.     {
  599.       vmnode = (RSYS_ValidMemoryNode *) node;
  600.  
  601.       Entries[i].se_obj_id.address = (APTR) (vmnode->vm_startaddress);
  602.  
  603.       sprintf (Entries[i].se_Entry, EntryAttr[MEMORYAREAS].ea_dataformat,
  604.            vmnode->vm_startaddress,
  605.            vmnode->vm_endaddress,
  606.            (char *) (IsValid (vmnode) ? "VAL" : "INV"),
  607.            (char *) (IsWriteProtect (vmnode) ? "R/O" : "WRI"),
  608.            (char *) (IsCacheable (vmnode) ? "CAC" : "NCA"),
  609.            vmnode->vm_comment);
  610.       i++;
  611.     }
  612.  
  613.   CreateEntryList (SORT, 0);
  614.  
  615.   PrintStatistics ();
  616.  
  617.   return;
  618. }
  619.